{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:47:56.287817Z",
     "start_time": "2025-02-26T08:47:52.977521Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 2.0.2\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:47:58.350531Z",
     "start_time": "2025-02-26T08:47:56.288352Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:47:58.355047Z",
     "start_time": "2025-02-26T08:47:58.351532Z"
    }
   },
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "# print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])\n",
    ")\n"
   ],
   "outputs": [],
   "execution_count": 3
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型\n",
    "\n",
    "这里我们没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，我们这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。感兴趣的同学可以自己动手修改并比对效果。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:47:58.378305Z",
     "start_time": "2025-02-26T08:47:58.355047Z"
    }
   },
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),  # in_features=784, out_features=300\n",
    "            nn.ReLU(),\n",
    "            nn.AlphaDropout(p=0.2) # 增加dropout，p=0.2表示以0.2的概率将某些神经元置0，防止过拟合\n",
    "        )\n",
    "        # 加19层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "            nn.AlphaDropout(p=0.2) # 增加dropout\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "\n",
    "print(f\"{'layer_name':^40}\\tparamerters num\")\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(\"{:<40}\\t{:^10}\".format(key, np.prod(value.shape)))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               layer_name               \tparamerters num\n",
      "linear_relu_stack.0.weight              \t  78400   \n",
      "linear_relu_stack.0.bias                \t   100    \n",
      "linear_relu_stack.Linear_1.weight       \t  10000   \n",
      "linear_relu_stack.Linear_1.bias         \t   100    \n",
      "linear_relu_stack.Linear_2.weight       \t  10000   \n",
      "linear_relu_stack.Linear_2.bias         \t   100    \n",
      "linear_relu_stack.Linear_3.weight       \t  10000   \n",
      "linear_relu_stack.Linear_3.bias         \t   100    \n",
      "linear_relu_stack.Linear_4.weight       \t  10000   \n",
      "linear_relu_stack.Linear_4.bias         \t   100    \n",
      "linear_relu_stack.Linear_5.weight       \t  10000   \n",
      "linear_relu_stack.Linear_5.bias         \t   100    \n",
      "linear_relu_stack.Linear_6.weight       \t  10000   \n",
      "linear_relu_stack.Linear_6.bias         \t   100    \n",
      "linear_relu_stack.Linear_7.weight       \t  10000   \n",
      "linear_relu_stack.Linear_7.bias         \t   100    \n",
      "linear_relu_stack.Linear_8.weight       \t  10000   \n",
      "linear_relu_stack.Linear_8.bias         \t   100    \n",
      "linear_relu_stack.Linear_9.weight       \t  10000   \n",
      "linear_relu_stack.Linear_9.bias         \t   100    \n",
      "linear_relu_stack.Linear_10.weight      \t  10000   \n",
      "linear_relu_stack.Linear_10.bias        \t   100    \n",
      "linear_relu_stack.Linear_11.weight      \t  10000   \n",
      "linear_relu_stack.Linear_11.bias        \t   100    \n",
      "linear_relu_stack.Linear_12.weight      \t  10000   \n",
      "linear_relu_stack.Linear_12.bias        \t   100    \n",
      "linear_relu_stack.Linear_13.weight      \t  10000   \n",
      "linear_relu_stack.Linear_13.bias        \t   100    \n",
      "linear_relu_stack.Linear_14.weight      \t  10000   \n",
      "linear_relu_stack.Linear_14.bias        \t   100    \n",
      "linear_relu_stack.Linear_15.weight      \t  10000   \n",
      "linear_relu_stack.Linear_15.bias        \t   100    \n",
      "linear_relu_stack.Linear_16.weight      \t  10000   \n",
      "linear_relu_stack.Linear_16.bias        \t   100    \n",
      "linear_relu_stack.Linear_17.weight      \t  10000   \n",
      "linear_relu_stack.Linear_17.bias        \t   100    \n",
      "linear_relu_stack.Linear_18.weight      \t  10000   \n",
      "linear_relu_stack.Linear_18.bias        \t   100    \n",
      "linear_relu_stack.Linear_19.weight      \t  10000   \n",
      "linear_relu_stack.Linear_19.bias        \t   100    \n",
      "linear_relu_stack.Output Layer.weight   \t   1000   \n",
      "linear_relu_stack.Output Layer.bias     \t    10    \n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:47:58.425841Z",
     "start_time": "2025-02-26T08:47:58.379307Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:48:01.349211Z",
     "start_time": "2025-02-26T08:47:58.425841Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:48:01.354009Z",
     "start_time": "2025-02-26T08:48:01.349211Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:48:01.372673Z",
     "start_time": "2025-02-26T08:48:01.354009Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T09:12:20.543541Z",
     "start_time": "2025-02-26T08:48:01.372673Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/dropout\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/dropout\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.001)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    "    )"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "18ec1d24250b4058bf4b98ebc1cee6e6"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 60 / global_step 225000\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T09:12:20.794328Z",
     "start_time": "2025-02-26T09:12:20.543541Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(6 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10000)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T09:12:22.252004Z",
     "start_time": "2025-02-26T09:12:20.795327Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "#推理时alphadropout的p值是0，通过加dropout，一定程度解决了过拟合\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/dropout/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3384\n",
      "accuracy: 0.8843\n"
     ]
    }
   ],
   "execution_count": 11
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
